/*
 * Canvas2Image v0.1
 * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com
 * MIT License [http://www.opensource.org/licenses/mit-license.php]
 */

var Canvas2Image = (function() {
	// check if we have canvas support
	var oCanvas = document.createElement("canvas"),
	    sc = String.fromCharCode,
      strDownloadMime = "image/octet-stream",
      bReplaceDownloadMime = false;
	
	// no canvas, bail out.
	if (!oCanvas.getContext) {
		return {
			saveAsBMP : function(){},
			saveAsPNG : function(){},
			saveAsJPEG : function(){}
		}
	}

	var bHasImageData = !!(oCanvas.getContext("2d").getImageData),
	    bHasDataURL = !!(oCanvas.toDataURL),
	    bHasBase64 = !!(window.btoa);

	// ok, we're good
	var readCanvasData = function(oCanvas) {
		var iWidth = parseInt(oCanvas.width),
		    iHeight = parseInt(oCanvas.height);
		return oCanvas.getContext("2d").getImageData(0,0,iWidth,iHeight);
	}

	// base64 encodes either a string or an array of charcodes
	var encodeData = function(data) {
		var i, aData, strData = "";
		
		if (typeof data == "string") {
			strData = data;
		} else {
			aData = data;
			for (i = 0; i < aData.length; i++) {
				strData += sc(aData[i]);
			}
		}
		return btoa(strData);
	}

	// creates a base64 encoded string containing BMP data takes an imagedata object as argument
	var createBMP = function(oData) {
		var strHeader = '',
		    iWidth = oData.width,
		    iHeight = oData.height;

		strHeader += 'BM';
	
		var iFileSize = iWidth*iHeight*4 + 54; // total header size = 54 bytes
		strHeader += sc(iFileSize % 256); iFileSize = Math.floor(iFileSize / 256);
		strHeader += sc(iFileSize % 256); iFileSize = Math.floor(iFileSize / 256);
		strHeader += sc(iFileSize % 256); iFileSize = Math.floor(iFileSize / 256);
		strHeader += sc(iFileSize % 256);

		strHeader += sc(0, 0, 0, 0, 54, 0, 0, 0); // data offset
		strHeader += sc(40, 0, 0, 0); // info header size

		var iImageWidth = iWidth;
		strHeader += sc(iImageWidth % 256); iImageWidth = Math.floor(iImageWidth / 256);
		strHeader += sc(iImageWidth % 256); iImageWidth = Math.floor(iImageWidth / 256);
		strHeader += sc(iImageWidth % 256); iImageWidth = Math.floor(iImageWidth / 256);
		strHeader += sc(iImageWidth % 256);
	
		var iImageHeight = iHeight;
		strHeader += sc(iImageHeight % 256); iImageHeight = Math.floor(iImageHeight / 256);
		strHeader += sc(iImageHeight % 256); iImageHeight = Math.floor(iImageHeight / 256);
		strHeader += sc(iImageHeight % 256); iImageHeight = Math.floor(iImageHeight / 256);
		strHeader += sc(iImageHeight % 256);
	
		strHeader += sc(1, 0, 32, 0); // num of planes & num of bits per pixel
		strHeader += sc(0, 0, 0, 0); // compression = none
	
		var iDataSize = iWidth*iHeight*4; 
		strHeader += sc(iDataSize % 256); iDataSize = Math.floor(iDataSize / 256);
		strHeader += sc(iDataSize % 256); iDataSize = Math.floor(iDataSize / 256);
		strHeader += sc(iDataSize % 256); iDataSize = Math.floor(iDataSize / 256);
		strHeader += sc(iDataSize % 256); 
	
		strHeader += sc(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // these bytes are not used
	
		var aImgData = oData.data,
		    strPixelData = "",
		    c, x, y = iHeight,
		    iOffsetX, iOffsetY, strPixelRow;
		
		do {
			iOffsetY = iWidth*(y-1)*4;
			strPixelRow = "";
			for (x = 0; x < iWidth; x++) {
				iOffsetX = 4*x;
				strPixelRow += sc(
					aImgData[iOffsetY + iOffsetX + 2], // B
					aImgData[iOffsetY + iOffsetX + 1], // G
					aImgData[iOffsetY + iOffsetX],     // R
					aImgData[iOffsetY + iOffsetX + 3]  // A
				);
			}
			strPixelData += strPixelRow;
		} while (--y);

		return encodeData(strHeader + strPixelData);
	}

	// sends the generated file to the client
	var saveFile = function(strData) {
		if (!window.open(strData)) {
			document.location.href = strData;
		}
	}

	var makeDataURI = function(strData, strMime) {
		return "data:" + strMime + ";base64," + strData;
	}

	// generates a <img> object containing the imagedata
	var makeImageObject = function(strSource) {
		var oImgElement = document.createElement("img");
		oImgElement.src = strSource;
		return oImgElement;
	}

	var scaleCanvas = function(oCanvas, iWidth, iHeight) {
		if (iWidth && iHeight) {
			var oSaveCanvas = document.createElement("canvas");
			
			oSaveCanvas.width = iWidth;
			oSaveCanvas.height = iHeight;
			oSaveCanvas.style.width = iWidth+"px";
			oSaveCanvas.style.height = iHeight+"px";

			var oSaveCtx = oSaveCanvas.getContext("2d");

			oSaveCtx.drawImage(oCanvas, 0, 0, oCanvas.width, oCanvas.height, 0, 0, iWidth, iWidth);
			
			return oSaveCanvas;
		}
		return oCanvas;
	}

	return {
		saveAsPNG : function(oCanvas, bReturnImg, iWidth, iHeight) {
			if (!bHasDataURL) return false;
			
			var oScaledCanvas = scaleCanvas(oCanvas, iWidth, iHeight),
          strMime = "image/png",
			    strData = oScaledCanvas.toDataURL(strMime);
				
			if (bReturnImg) {
				return makeImageObject(strData);
			} else {
				saveFile(bReplaceDownloadMime ? strData.replace(strMime, strDownloadMime) : strData);
			}
			return true;
		},

		saveAsJPEG : function(oCanvas, bReturnImg, iWidth, iHeight) {
			if (!bHasDataURL) return false;

			var oScaledCanvas = scaleCanvas(oCanvas, iWidth, iHeight),
			    strMime = "image/jpeg",
			    strData = oScaledCanvas.toDataURL(strMime);
	
			// check if browser actually supports jpeg by looking for the mime type in the data uri. if not, return false
			if (strData.indexOf(strMime) != 5) return false;

			if (bReturnImg) {
				return makeImageObject(strData);
			} else {
        saveFile(bReplaceDownloadMime ? strData.replace(strMime, strDownloadMime) : strData);
			}
			return true;
		},

		saveAsBMP : function(oCanvas, bReturnImg, iWidth, iHeight) {
			if (!(bHasDataURL && bHasImageData && bHasBase64)) return false;

			var oScaledCanvas = scaleCanvas(oCanvas, iWidth, iHeight),
          strMime = "image/bmp",
			    oData = readCanvasData(oScaledCanvas),
			    strImgData = createBMP(oData);
				
			if (bReturnImg) {
				return makeImageObject(makeDataURI(strImgData, strMime));
			} else {
        saveFile(makeDataURI(strImgData, strMime));
			}
			return true;
		}
	};
})();